home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / os2 / ooxdb200.zip / ooxmemo.xh < prev    next >
Text File  |  1996-11-13  |  23KB  |  844 lines
  1.  
  2. /*
  3.  * This file was generated by the SOM Compiler.
  4.  * FileName: ooxmemo.xh.
  5.  * Generated using:
  6.  *     SOM Precompiler somipc: 2.29.1.17
  7.  *     SOM Emitter emitxh: 2.47
  8.  */
  9.  
  10. #ifndef SOM_ooxmemo_xh
  11. #define SOM_ooxmemo_xh
  12.  
  13. class ooxmemo;
  14.  
  15. /*
  16.  * Symbol parentComment is undefined
  17.  */
  18.  
  19. #define ooxmemo_MajorVersion 0
  20. #define ooxmemo_MinorVersion 0
  21.  
  22. /* C++ SOM defs */
  23. #include <somcls.xh>
  24. #include <somcm.xh>
  25.  
  26. /* C++ parent defs */
  27. #ifndef SOM_ooxfield_xh
  28. #include <ooxfield.xh>
  29. #endif
  30.  
  31. #ifndef ooxmemo_API
  32. #define ooxmemo_API
  33. /*
  34.  * -- The Class API
  35.  */
  36.  
  37. /*
  38.  * Start of bindings for IDL types
  39.  */
  40.  
  41. class SOMClass;
  42. class SOMObject;
  43. class dbt;
  44. class dbt_iv;
  45. class ooxbase;
  46.  
  47. /*
  48.  * End of bindings for IDL types.
  49.  */
  50.  
  51. /* A procedure to create the ooxmemo Class */
  52. SOMEXTERN SOMClass * SOMLINK ooxmemoNewClass(
  53.         integer4 majorVersion,
  54.         integer4 minorVersion);
  55.  
  56. /* The API to the ooxmemo class object, and the methods it introduces. */
  57. SOMEXTERN struct ooxmemoClassDataStructure {
  58.     SOMClass *classObject;
  59.     somMToken define;
  60. } SOMDLINK ooxmemoClassData;
  61. #define _ooxmemo ooxmemoClassData.classObject
  62.  
  63. /* The API to parentMtabs for ooxmemo, and the instance data it introduces. */
  64. SOMEXTERN struct ooxmemoCClassDataStructure {
  65.     somMethodTabs parentMtab;
  66.     somDToken              instanceDataToken;
  67. } SOMDLINK ooxmemoCClassData;
  68.  
  69. /*
  70.  * -- Typedefs for ooxmemo Method Procedures
  71.  */
  72. SOMEXTERN {
  73. typedef void   SOMLINK somTP_ooxmemo_define(ooxmemo *somSelf, 
  74.         somInitCtrl* ctrl, 
  75.         string name);
  76. typedef somTP_ooxmemo_define *somTD_ooxmemo_define;
  77.  
  78. /*
  79.  * -- Typedefs for Reintroduced Wrapper Methods
  80.  */
  81. typedef string   SOMLINK somTP_ooxmemo_get_name(ooxmemo *somSelf);
  82. typedef somTP_ooxmemo_get_name *somTD_ooxmemo_get_name;
  83. typedef string   SOMLINK somTP_ooxmemo_get(ooxmemo *somSelf);
  84. typedef somTP_ooxmemo_get *somTD_ooxmemo_get;
  85. typedef long   SOMLINK somTP_ooxmemo_put(ooxmemo *somSelf, 
  86.         string datum);
  87. typedef somTP_ooxmemo_put *somTD_ooxmemo_put;
  88. typedef char   SOMLINK somTP_ooxmemo_get_type(ooxmemo *somSelf);
  89. typedef somTP_ooxmemo_get_type *somTD_ooxmemo_get_type;
  90. typedef short   SOMLINK somTP_ooxmemo_get_length(ooxmemo *somSelf);
  91. typedef somTP_ooxmemo_get_length *somTD_ooxmemo_get_length;
  92. typedef short   SOMLINK somTP_ooxmemo_get_dec_point(ooxmemo *somSelf);
  93. typedef somTP_ooxmemo_get_dec_point *somTD_ooxmemo_get_dec_point;
  94. typedef void   SOMLINK somTP_ooxmemo_somDefaultInit(ooxmemo *somSelf, 
  95.         som3InitCtrl* ctrl);
  96. typedef somTP_ooxmemo_somDefaultInit *somTD_ooxmemo_somDefaultInit;
  97. typedef void   SOMLINK somTP_ooxmemo_somUninit(ooxmemo *somSelf);
  98. typedef somTP_ooxmemo_somUninit *somTD_ooxmemo_somUninit;
  99. typedef void   SOMLINK somTP_ooxmemo_somDestruct(ooxmemo *somSelf, 
  100.         octet doFree, 
  101.         som3DestructCtrl* ctrl);
  102. typedef somTP_ooxmemo_somDestruct *somTD_ooxmemo_somDestruct;
  103. typedef void   SOMLINK somTP_ooxmemo_somDefaultCopyInit(ooxmemo *somSelf, 
  104.         som3InitCtrl* ctrl, 
  105.         SOMObject* fromObj);
  106. typedef somTP_ooxmemo_somDefaultCopyInit *somTD_ooxmemo_somDefaultCopyInit;
  107. typedef ooxmemo*   SOMLINK somTP_ooxmemo_somDefaultAssign(ooxmemo *somSelf, 
  108.         som3AssignCtrl* ctrl, 
  109.         SOMObject* fromObj);
  110. typedef somTP_ooxmemo_somDefaultAssign *somTD_ooxmemo_somDefaultAssign;
  111. typedef void   SOMLINK somTP_ooxmemo_somDefaultConstCopyInit(ooxmemo *somSelf, 
  112.         som3InitCtrl* ctrl, 
  113.         SOMObject* fromObj);
  114. typedef somTP_ooxmemo_somDefaultConstCopyInit *somTD_ooxmemo_somDefaultConstCopyInit;
  115. typedef void   SOMLINK somTP_ooxmemo_somDefaultVCopyInit(ooxmemo *somSelf, 
  116.         som3InitCtrl* ctrl, 
  117.         SOMObject* fromObj);
  118. typedef somTP_ooxmemo_somDefaultVCopyInit *somTD_ooxmemo_somDefaultVCopyInit;
  119. typedef void   SOMLINK somTP_ooxmemo_somDefaultConstVCopyInit(ooxmemo *somSelf, 
  120.         som3InitCtrl* ctrl, 
  121.         SOMObject* fromObj);
  122. typedef somTP_ooxmemo_somDefaultConstVCopyInit *somTD_ooxmemo_somDefaultConstVCopyInit;
  123. typedef ooxmemo*   SOMLINK somTP_ooxmemo_somDefaultConstAssign(ooxmemo *somSelf, 
  124.         som3AssignCtrl* ctrl, 
  125.         SOMObject* fromObj);
  126. typedef somTP_ooxmemo_somDefaultConstAssign *somTD_ooxmemo_somDefaultConstAssign;
  127. typedef ooxmemo*   SOMLINK somTP_ooxmemo_somDefaultVAssign(ooxmemo *somSelf, 
  128.         som3AssignCtrl* ctrl, 
  129.         SOMObject* fromObj);
  130. typedef somTP_ooxmemo_somDefaultVAssign *somTD_ooxmemo_somDefaultVAssign;
  131. typedef ooxmemo*   SOMLINK somTP_ooxmemo_somDefaultConstVAssign(ooxmemo *somSelf, 
  132.         som3AssignCtrl* ctrl, 
  133.         SOMObject* fromObj);
  134. typedef somTP_ooxmemo_somDefaultConstVAssign *somTD_ooxmemo_somDefaultConstVAssign;
  135. typedef void   SOMLINK somTP_ooxmemo_somInit(ooxmemo *somSelf);
  136. typedef somTP_ooxmemo_somInit *somTD_ooxmemo_somInit;
  137. typedef void   SOMLINK somTP_ooxmemo_somFree(ooxmemo *somSelf);
  138. typedef somTP_ooxmemo_somFree *somTD_ooxmemo_somFree;
  139. typedef SOMClass*   SOMLINK somTP_ooxmemo_somGetClass(ooxmemo *somSelf);
  140. typedef somTP_ooxmemo_somGetClass *somTD_ooxmemo_somGetClass;
  141. typedef string   SOMLINK somTP_ooxmemo_somGetClassName(ooxmemo *somSelf);
  142. typedef somTP_ooxmemo_somGetClassName *somTD_ooxmemo_somGetClassName;
  143. typedef long   SOMLINK somTP_ooxmemo_somGetSize(ooxmemo *somSelf);
  144. typedef somTP_ooxmemo_somGetSize *somTD_ooxmemo_somGetSize;
  145. typedef boolean   SOMLINK somTP_ooxmemo_somIsA(ooxmemo *somSelf, 
  146.         SOMClass* aClassObj);
  147. typedef somTP_ooxmemo_somIsA *somTD_ooxmemo_somIsA;
  148. typedef boolean   SOMLINK somTP_ooxmemo_somIsInstanceOf(ooxmemo *somSelf, 
  149.         SOMClass* aClassObj);
  150. typedef somTP_ooxmemo_somIsInstanceOf *somTD_ooxmemo_somIsInstanceOf;
  151. typedef boolean   SOMLINK somTP_ooxmemo_somRespondsTo(ooxmemo *somSelf, 
  152.         somId mId);
  153. typedef somTP_ooxmemo_somRespondsTo *somTD_ooxmemo_somRespondsTo;
  154. typedef boolean   SOMLINK somTP_ooxmemo_somDispatch(ooxmemo *somSelf, 
  155.         somToken* retValue, 
  156.         somId methodId, 
  157.         va_list ap);
  158. typedef somTP_ooxmemo_somDispatch *somTD_ooxmemo_somDispatch;
  159. typedef boolean   SOMLINK somTP_ooxmemo_somClassDispatch(ooxmemo *somSelf, 
  160.         SOMClass* clsObj, 
  161.         somToken* retValue, 
  162.         somId methodId, 
  163.         va_list ap);
  164. typedef somTP_ooxmemo_somClassDispatch *somTD_ooxmemo_somClassDispatch;
  165. typedef boolean   SOMLINK somTP_ooxmemo_somCastObj(ooxmemo *somSelf, 
  166.         SOMClass* cls);
  167. typedef somTP_ooxmemo_somCastObj *somTD_ooxmemo_somCastObj;
  168. typedef boolean   SOMLINK somTP_ooxmemo_somResetObj(ooxmemo *somSelf);
  169. typedef somTP_ooxmemo_somResetObj *somTD_ooxmemo_somResetObj;
  170. typedef void   SOMLINK somTP_ooxmemo_somDispatchV(ooxmemo *somSelf, 
  171.         somId methodId, 
  172.         somId descriptor, 
  173.         va_list ap);
  174. typedef somTP_ooxmemo_somDispatchV *somTD_ooxmemo_somDispatchV;
  175. typedef long   SOMLINK somTP_ooxmemo_somDispatchL(ooxmemo *somSelf, 
  176.         somId methodId, 
  177.         somId descriptor, 
  178.         va_list ap);
  179. typedef somTP_ooxmemo_somDispatchL *somTD_ooxmemo_somDispatchL;
  180. typedef void*   SOMLINK somTP_ooxmemo_somDispatchA(ooxmemo *somSelf, 
  181.         somId methodId, 
  182.         somId descriptor, 
  183.         va_list ap);
  184. typedef somTP_ooxmemo_somDispatchA *somTD_ooxmemo_somDispatchA;
  185. typedef double   SOMLINK somTP_ooxmemo_somDispatchD(ooxmemo *somSelf, 
  186.         somId methodId, 
  187.         somId descriptor, 
  188.         va_list ap);
  189. typedef somTP_ooxmemo_somDispatchD *somTD_ooxmemo_somDispatchD;
  190. typedef SOMObject*   SOMLINK somTP_ooxmemo_somPrintSelf(ooxmemo *somSelf);
  191. typedef somTP_ooxmemo_somPrintSelf *somTD_ooxmemo_somPrintSelf;
  192. typedef void   SOMLINK somTP_ooxmemo_somDumpSelf(ooxmemo *somSelf, 
  193.         long level);
  194. typedef somTP_ooxmemo_somDumpSelf *somTD_ooxmemo_somDumpSelf;
  195. typedef void   SOMLINK somTP_ooxmemo_somDumpSelfInt(ooxmemo *somSelf, 
  196.         long level);
  197. typedef somTP_ooxmemo_somDumpSelfInt *somTD_ooxmemo_somDumpSelfInt;
  198. }
  199.  
  200. #endif /* ooxmemo_API */
  201.  
  202.  
  203. /*
  204.  * -- This emitter treats Method Tokens as Thunks by default.
  205.  * -- Use the sc modifier "nothunks" to change this default
  206.  */
  207. #undef somresolve_
  208. #define somresolve_(obj,mToken) ((somMethodProc*)((void)obj, mToken))
  209.  
  210. /*
  211.  * -- The C++ Wrapper Class for ooxmemo
  212.  */
  213. class ooxmemo : public ooxfield
  214. {
  215. /*
  216.  * Symbol parentComment is undefined
  217.  */
  218. public:
  219.  
  220. // ooxmemo::new creates the class object if necessary, and then uses somNewNoInit
  221. // to allocate memory and create the object. Initialization is in ctors.
  222. void *operator new(size_t)
  223. {
  224.    if (!_ooxmemo) ooxmemoNewClass(ooxmemo_MajorVersion,ooxmemo_MinorVersion);
  225.    return (void*)
  226.       SOM_Resolve(_ooxmemo,SOMClass,somNewNoInit)
  227.          ((SOMClass *)((void*)_ooxmemo));
  228. }
  229.  
  230. // ooxmemo::delete uses somDestruct.
  231. void operator delete(void * obj)
  232. {
  233.    if (obj && *(void**)obj) {
  234.       SOM_Resolve(obj,SOMObject,somFree)
  235.          ((SOMObject*)obj);
  236.    }
  237. }
  238.  
  239. ooxmemo& operator=(ooxmemo& fromObj)
  240. {
  241.    this->somDefaultAssign(0,(SOMObject*)((void*)&fromObj));
  242.    return *this;
  243. }
  244.  
  245. ooxmemo()
  246. {
  247.    if (*(void**)this != 
  248.        ((somParentMtabStructPtr)
  249.         (ooxmemoCClassData.parentMtab))->mtab)
  250.       return;
  251.    ((SOMObject*)((void*)this))->somDefaultInit(0);
  252. }
  253.  
  254. ooxmemo(ooxmemo* fromObj)
  255. {
  256.    if (*(void**)this != 
  257.        ((somParentMtabStructPtr)
  258.         (ooxmemoCClassData.parentMtab))->mtab)
  259.       return;
  260.    ((SOMObject*)((void*)this))->somDefaultCopyInit(0,((SOMObject*)((void*)fromObj)));
  261. }
  262.  
  263. #ifdef __IBMCPP__
  264. #pragma info(nocnv,nopar)
  265. #endif
  266. ooxmemo(const ooxmemo* fromObj)
  267. {
  268.    if (*(void**)this != 
  269.        ((somParentMtabStructPtr)
  270.         (ooxmemoCClassData.parentMtab))->mtab)
  271.       return;
  272.    ((SOMObject*)((void*)this))->somDefaultConstCopyInit(0,((SOMObject*)((void*)fromObj)));
  273. }
  274. #ifdef __IBMCPP__
  275. #pragma info(restore)
  276. #endif
  277.  
  278. ooxmemo(string name) 
  279. {
  280.    define(0,name);
  281. }
  282.  
  283.  
  284. /* initializer method: define */
  285. void   define(somInitCtrl* ctrl, 
  286.         string name)
  287. {
  288.    SOM_ResolveD(this,ooxmemo,ooxmemo,define)
  289.     (this,ctrl,name);
  290. }
  291.  
  292.  
  293. /*
  294.  * Reintroduce inherited methods
  295.  */
  296.  
  297. /* method: get_name */
  298. string   get_name()
  299. {
  300.    return SOM_ResolveD(this,ooxmemo,ooxfield,get_name)
  301.     (this);
  302. }
  303.  
  304.  
  305. /* method: get */
  306. string   get()
  307. {
  308.    return SOM_ResolveD(this,ooxmemo,ooxfield,get)
  309.     (this);
  310. }
  311.  
  312.  
  313. /* method: put */
  314. long   put(string datum)
  315. {
  316.    return SOM_ResolveD(this,ooxmemo,ooxfield,put)
  317.     (this,datum);
  318. }
  319.  
  320.  
  321. /* method: get_type */
  322. char   get_type()
  323. {
  324.    return SOM_ResolveD(this,ooxmemo,ooxfield,get_type)
  325.     (this);
  326. }
  327.  
  328.  
  329. /* method: get_length */
  330. short   get_length()
  331. {
  332.    return SOM_ResolveD(this,ooxmemo,ooxfield,get_length)
  333.     (this);
  334. }
  335.  
  336.  
  337. /* method: get_dec_point */
  338. short   get_dec_point()
  339. {
  340.    return SOM_ResolveD(this,ooxmemo,ooxfield,get_dec_point)
  341.     (this);
  342. }
  343.  
  344.  
  345. /* initializer method: somDefaultInit */
  346. void   somDefaultInit(som3InitCtrl* ctrl)
  347. {
  348.    SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultInit)
  349.     (this,ctrl);
  350. }
  351.  
  352.  
  353. /* method: somUninit */
  354. void   somUninit()
  355. {
  356.    SOM_ResolveD(this,ooxmemo,SOMObject,somUninit)
  357.     (this);
  358. }
  359.  
  360.  
  361. /* method: somDestruct */
  362. void   somDestruct(octet doFree, 
  363.         som3DestructCtrl* ctrl)
  364. {
  365. /*
  366.  *  The default destructor for a SOM object. A nonzero <doFree>
  367.  *  indicates that the object storage should be freed by the
  368.  *  object's class (via somDeallocate) after uninitialization.
  369.  *  As with somDefaultInit, a null ctrl can be passed.
  370.  */
  371.    SOM_ResolveD(this,ooxmemo,SOMObject,somDestruct)
  372.     (this,doFree,ctrl);
  373. }
  374.  
  375.  
  376. /* initializer method: somDefaultCopyInit */
  377. void   somDefaultCopyInit(som3InitCtrl* ctrl, 
  378.         SOMObject* fromObj)
  379. {
  380. /*
  381.  *  A default copy constructor. Use this to make copies of objects for
  382.  *  calling methods with "by-value" argument semantics.
  383.  */
  384.    SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultCopyInit)
  385.     (this,ctrl,fromObj);
  386. }
  387.  
  388.  
  389. /* method: somDefaultAssign */
  390. ooxmemo*  somDefaultAssign(som3AssignCtrl* ctrl, 
  391.         SOMObject* fromObj)
  392. {
  393. /*
  394.  *  A default assignment operator. Use this to "assign" the state of one
  395.  *  object to another.
  396.  */
  397.    return SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultAssign)
  398.     (this,ctrl,fromObj);
  399. }
  400.  
  401.  
  402. /* initializer method: somDefaultConstCopyInit */
  403. void   somDefaultConstCopyInit(som3InitCtrl* ctrl, 
  404.         SOMObject* fromObj)
  405. {
  406. /*
  407.  *  A default copy constructor that uses a const fromObj.
  408.  */
  409.    SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultConstCopyInit)
  410.     (this,ctrl,fromObj);
  411. }
  412.  
  413.  
  414. /* initializer method: somDefaultVCopyInit */
  415. void   somDefaultVCopyInit(som3InitCtrl* ctrl, 
  416.         SOMObject* fromObj)
  417. {
  418. /*
  419.  *  A default copy constructor that uses a volatile fromObj.
  420.  */
  421.    SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultVCopyInit)
  422.     (this,ctrl,fromObj);
  423. }
  424.  
  425.  
  426. /* initializer method: somDefaultConstVCopyInit */
  427. void   somDefaultConstVCopyInit(som3InitCtrl* ctrl, 
  428.         SOMObject* fromObj)
  429. {
  430. /*
  431.  *  A default copy constructor that uses a const volatile fromObj.
  432.  */
  433.    SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultConstVCopyInit)
  434.     (this,ctrl,fromObj);
  435. }
  436.  
  437.  
  438. /* method: somDefaultConstAssign */
  439. ooxmemo*  somDefaultConstAssign(som3AssignCtrl* ctrl, 
  440.         SOMObject* fromObj)
  441. {
  442. /*
  443.  *  A default assignment operator that uses a const fromObj.
  444.  */
  445.    return SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultConstAssign)
  446.     (this,ctrl,fromObj);
  447. }
  448.  
  449.  
  450. /* method: somDefaultVAssign */
  451. ooxmemo*  somDefaultVAssign(som3AssignCtrl* ctrl, 
  452.         SOMObject* fromObj)
  453. {
  454. /*
  455.  *  A default assignment operator that uses a volatile fromObj.
  456.  */
  457.    return SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultVAssign)
  458.     (this,ctrl,fromObj);
  459. }
  460.  
  461.  
  462. /* method: somDefaultConstVAssign */
  463. ooxmemo*  somDefaultConstVAssign(som3AssignCtrl* ctrl, 
  464.         SOMObject* fromObj)
  465. {
  466. /*
  467.  *  A default assignment operator that uses a const volatile fromObj.
  468.  */
  469.    return SOM_ResolveD(this,ooxmemo,SOMObject,somDefaultConstVAssign)
  470.     (this,ctrl,fromObj);
  471. }
  472.  
  473.  
  474. /* method: somInit */
  475. void   somInit()
  476. {
  477. /*
  478.  *  Obsolete but still supported. Override somDefaultInit instead of somInit.
  479.  */
  480.    SOM_ResolveD(this,ooxmemo,SOMObject,somInit)
  481.     (this);
  482. }
  483.  
  484.  
  485. /* method: somFree */
  486. void   somFree()
  487. {
  488. /*
  489.  *  Use as directed by framework implementations.
  490.  */
  491.    SOM_ResolveD(this,ooxmemo,SOMObject,somFree)
  492.     (this);
  493. }
  494.  
  495.  
  496. /* method: somGetClass */
  497. SOMClass*   somGetClass()
  498. {
  499. /*
  500.  *  Return the receiver's class.
  501.  */
  502.    return SOM_ResolveD(this,ooxmemo,SOMObject,somGetClass)
  503.     (this);
  504. }
  505.  
  506.  
  507. /* method: somGetClassName */
  508. string   somGetClassName()
  509. {
  510. /*
  511.  *  Return the name of the receiver's class.
  512.  */
  513.    return SOM_ResolveD(this,ooxmemo,SOMObject,somGetClassName)
  514.     (this);
  515. }
  516.  
  517.  
  518. /* method: somGetSize */
  519. long   somGetSize()
  520. {
  521. /*
  522.  *  Return the size of the receiver.
  523.  */
  524.    return SOM_ResolveD(this,ooxmemo,SOMObject,somGetSize)
  525.     (this);
  526. }
  527.  
  528.  
  529. /* method: somIsA */
  530. boolean   somIsA(SOMClass* aClassObj)
  531. {
  532. /*
  533.  *  Returns 1 (true) if the receiver responds to methods
  534.  *  introduced by <aClassObj>, and 0 (false) otherwise.
  535.  */
  536.    return SOM_ResolveD(this,ooxmemo,SOMObject,somIsA)
  537.     (this,aClassObj);
  538. }
  539.  
  540.  
  541. /* method: somIsInstanceOf */
  542. boolean   somIsInstanceOf(SOMClass* aClassObj)
  543. {
  544. /*
  545.  *  Returns 1 (true) if the receiver is an instance of
  546.  *  <aClassObj> and 0 (false) otherwise.
  547.  */
  548.    return SOM_ResolveD(this,ooxmemo,SOMObject,somIsInstanceOf)
  549.     (this,aClassObj);
  550. }
  551.  
  552.  
  553. /* method: somRespondsTo */
  554. boolean   somRespondsTo(somId mId)
  555. {
  556. /*
  557.  *  Returns 1 (true) if the indicated method can be invoked
  558.  *  on the receiver and 0 (false) otherwise.
  559.  */
  560.    return SOM_ResolveD(this,ooxmemo,SOMObject,somRespondsTo)
  561.     (this,mId);
  562. }
  563.  
  564.  
  565. /* va_list method: somDispatch */
  566.  
  567. /*
  568.  *  This method provides a generic, class-specific dispatch mechanism.
  569.  *  It accepts as input <retValue> a pointer to the memory area to be
  570.  *  loaded with the result of dispatching the method indicated by
  571.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  572.  *  on which the method is to be invoked as the first argument.
  573.  */
  574. /* the va_list invocation form */
  575. boolean   ooxmemo_somDispatch(somToken* retValue, 
  576.         somId methodId, 
  577.         va_list ap)
  578. {return SOM_ResolveD(this,ooxmemo,SOMObject,somDispatch)
  579.     (this,retValue,methodId,ap);
  580. }
  581.  
  582. /* the varargs invocation form */
  583. boolean   somDispatch(somToken* retValue, 
  584.         somId methodId, 
  585.         ...)
  586. {
  587. /*
  588.  *  This method provides a generic, class-specific dispatch mechanism.
  589.  *  It accepts as input <retValue> a pointer to the memory area to be
  590.  *  loaded with the result of dispatching the method indicated by
  591.  *  <methodId> using the arguments in <ap>. <ap> contains the object
  592.  *  on which the method is to be invoked as the first argument.
  593.  */
  594.    va_list ap;
  595.    va_start(ap, methodId);
  596.    boolean __somResult = 
  597.       SOM_ResolveD(this,ooxmemo,SOMObject,somDispatch)
  598.     (this,retValue,methodId,ap);
  599.    va_end(ap);
  600.    return __somResult;
  601. }
  602.  
  603.  
  604. /* va_list method: somClassDispatch */
  605.  
  606. /*
  607.  *  Like somDispatch, but method resolution for static methods is done
  608.  *  according to the clsObj instance method table.
  609.  */
  610. /* the va_list invocation form */
  611. boolean   ooxmemo_somClassDispatch(SOMClass* clsObj, 
  612.         somToken* retValue, 
  613.         somId methodId, 
  614.         va_list ap)
  615. {return SOM_ResolveD(this,ooxmemo,SOMObject,somClassDispatch)
  616.     (this,clsObj,retValue,methodId,ap);
  617. }
  618.  
  619. /* the varargs invocation form */
  620. boolean   somClassDispatch(SOMClass* clsObj, 
  621.         somToken* retValue, 
  622.         somId methodId, 
  623.         ...)
  624. {
  625. /*
  626.  *  Like somDispatch, but method resolution for static methods is done
  627.  *  according to the clsObj instance method table.
  628.  */
  629.    va_list ap;
  630.    va_start(ap, methodId);
  631.    boolean __somResult = 
  632.       SOM_ResolveD(this,ooxmemo,SOMObject,somClassDispatch)
  633.     (this,clsObj,retValue,methodId,ap);
  634.    va_end(ap);
  635.    return __somResult;
  636. }
  637.  
  638.  
  639. /* method: somCastObj */
  640. boolean   somCastObj(SOMClass* cls)
  641. {
  642. /*
  643.  *  cast the receiving object to cls (which must be an ancestor of the
  644.  *  objects true class. Returns true on success.
  645.  */
  646.    return SOM_ResolveD(this,ooxmemo,SOMObject,somCastObj)
  647.     (this,cls);
  648. }
  649.  
  650.  
  651. /* method: somResetObj */
  652. boolean   somResetObj()
  653. {
  654. /*
  655.  *  reset an object to its true class. Returns true always.
  656.  */
  657.    return SOM_ResolveD(this,ooxmemo,SOMObject,somResetObj)
  658.     (this);
  659. }
  660.  
  661.  
  662. /* va_list method: somDispatchV */
  663.  
  664. /*
  665.  *  Obsolete. Use somDispatch instead.
  666.  */
  667. /* the va_list invocation form */
  668. void   ooxmemo_somDispatchV(somId methodId, 
  669.         somId descriptor, 
  670.         va_list ap)
  671. {   SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchV)
  672.     (this,methodId,descriptor,ap);
  673. }
  674.  
  675. /* the varargs invocation form */
  676. void   somDispatchV(somId methodId, 
  677.         somId descriptor, 
  678.         ...)
  679. {
  680. /*
  681.  *  Obsolete. Use somDispatch instead.
  682.  */
  683.    va_list ap;
  684.    va_start(ap, descriptor);
  685.    SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchV)
  686.     (this,methodId,descriptor,ap);
  687.    va_end(ap);
  688. }
  689.  
  690.  
  691. /* va_list method: somDispatchL */
  692.  
  693. /*
  694.  *  Obsolete. Use somDispatch instead.
  695.  */
  696. /* the va_list invocation form */
  697. long   ooxmemo_somDispatchL(somId methodId, 
  698.         somId descriptor, 
  699.         va_list ap)
  700. {return SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchL)
  701.     (this,methodId,descriptor,ap);
  702. }
  703.  
  704. /* the varargs invocation form */
  705. long   somDispatchL(somId methodId, 
  706.         somId descriptor, 
  707.         ...)
  708. {
  709. /*
  710.  *  Obsolete. Use somDispatch instead.
  711.  */
  712.    va_list ap;
  713.    va_start(ap, descriptor);
  714.    long __somResult = 
  715.       SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchL)
  716.     (this,methodId,descriptor,ap);
  717.    va_end(ap);
  718.    return __somResult;
  719. }
  720.  
  721.  
  722. /* va_list method: somDispatchA */
  723.  
  724. /*
  725.  *  Obsolete. Use somDispatch instead.
  726.  */
  727. /* the va_list invocation form */
  728. void*   ooxmemo_somDispatchA(somId methodId, 
  729.         somId descriptor, 
  730.         va_list ap)
  731. {return SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchA)
  732.     (this,methodId,descriptor,ap);
  733. }
  734.  
  735. /* the varargs invocation form */
  736. void*   somDispatchA(somId methodId, 
  737.         somId descriptor, 
  738.         ...)
  739. {
  740. /*
  741.  *  Obsolete. Use somDispatch instead.
  742.  */
  743.    va_list ap;
  744.    va_start(ap, descriptor);
  745.    void* __somResult = 
  746.       SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchA)
  747.     (this,methodId,descriptor,ap);
  748.    va_end(ap);
  749.    return __somResult;
  750. }
  751.  
  752.  
  753. /* va_list method: somDispatchD */
  754.  
  755. /*
  756.  *  Obsolete. Use somDispatch instead.
  757.  */
  758. /* the va_list invocation form */
  759. double   ooxmemo_somDispatchD(somId methodId, 
  760.         somId descriptor, 
  761.         va_list ap)
  762. {return SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchD)
  763.     (this,methodId,descriptor,ap);
  764. }
  765.  
  766. /* the varargs invocation form */
  767. double   somDispatchD(somId methodId, 
  768.         somId descriptor, 
  769.         ...)
  770. {
  771. /*
  772.  *  Obsolete. Use somDispatch instead.
  773.  */
  774.    va_list ap;
  775.    va_start(ap, descriptor);
  776.    double __somResult = 
  777.       SOM_ResolveD(this,ooxmemo,SOMObject,somDispatchD)
  778.     (this,methodId,descriptor,ap);
  779.    va_end(ap);
  780.    return __somResult;
  781. }
  782.  
  783.  
  784. /* method: somPrintSelf */
  785. SOMObject*   somPrintSelf()
  786. {
  787. /*
  788.  *  Uses <SOMOutCharRoutine> to write a brief string with identifying
  789.  *  information about this object.  The default implementation just gives
  790.  *  the object's class name and its address in memory.
  791.  *  <self> is returned.
  792.  */
  793.    return SOM_ResolveD(this,ooxmemo,SOMObject,somPrintSelf)
  794.     (this);
  795. }
  796.  
  797.  
  798. /* method: somDumpSelf */
  799. void   somDumpSelf(long level)
  800. {
  801. /*
  802.  *  Uses <SOMOutCharRoutine> to write a detailed description of this object
  803.  *  and its current state.
  804.  * 
  805.  *  <level> indicates the nesting level for describing compound objects
  806.  *  it must be greater than or equal to zero.  All lines in the
  807.  *  description will be preceeded by <2*level> spaces.
  808.  * 
  809.  *  This routine only actually writes the data that concerns the object
  810.  *  as a whole, such as class, and uses <somDumpSelfInt> to describe
  811.  *  the object's current state.  This approach allows readable
  812.  *  descriptions of compound objects to be constructed.
  813.  * 
  814.  *  Generally it is not necessary to override this method, if it is
  815.  *  overriden it generally must be completely replaced.
  816.  */
  817.    SOM_ResolveD(this,ooxmemo,SOMObject,somDumpSelf)
  818.     (this,level);
  819. }
  820.  
  821.  
  822. /* method: somDumpSelfInt */
  823. void   somDumpSelfInt(long level)
  824. {
  825. /*
  826.  *  Uses <SOMOutCharRoutine> to write in the current state of this object.
  827.  *  Generally this method will need to be overridden.  When overriding
  828.  *  it, begin by calling the parent class form of this method and then
  829.  *  write in a description of your class's instance data. This will
  830.  *  result in a description of all the object's instance data going
  831.  *  from its root ancestor class to its specific class.
  832.  */
  833.    SOM_ResolveD(this,ooxmemo,SOMObject,somDumpSelfInt)
  834.     (this,level);
  835. }
  836.  
  837.  
  838.  
  839. };   /* ooxmemo */
  840.  
  841.  
  842.  
  843. #endif       /* SOM_ooxmemo_xh */
  844.